import L from "leaflet";
import "leaflet.markercluster";
import HeatmapOverlay from "leaflet-heatmap";
// import 'leaflet-tilelayer-baidu';
import "leaflet-canvas-layer";
import proj4 from "proj4";
import gcoord from "gcoord";
import { gcjTobd, bdTogcj } from "@/utils/eviltransform";
import { mapConfig } from "@/config/map";
import { cloneDeep } from "lodash-es";

// 添加地图默认中心点坐标（北京）
const MAP_CENTER: [number, number] = [39.9042, 116.4074];
const markerHtmlStyles = `
  background-color: #ffffff;
  border: 2px solid #147617;
  width: 16px;
  height: 16px;
  display: block;
  border-radius: 50%;`;

const fenceIcon = L.divIcon({
  className: "my-custom-pin",
  iconAnchor: [8, 8],
  html: `<span style="${markerHtmlStyles}" />`
});

// 定义CGCS2000坐标系
proj4.defs("EPSG:4490", "+proj=longlat +ellps=GRS80 +no_defs");

/**
 * CGCS2000坐标系(2000国家大地坐标系)转换成GCJ02坐标系(火星坐标系)
 * @param _lat 纬度
 * @param _lng 经度
 * @returns 新经纬度
 */
export function cgcs2000Togcj02(_lat: number, _lng: number) {
  let [lng, lat] = proj4("EPSG:4490", [_lng, _lat]);
  [lng, lat] = gcoord.transform([lng, lat], gcoord.WGS84, gcoord.GCJ02);
  return { lat, lng };
}

/**
 * WGS84坐标系(经纬度坐标系)转换成CGCS2000坐标系(2000国家大地坐标系)
 * @param _lat 纬度
 * @param _lng 经度
 * @returns 新经纬度
 */
export function wgsTocgcs2000(_lat: number, _lng: number) {
  const [lng, lat] = proj4("EPSG:4326", "EPSG:4490", [_lng, _lat]);
  return { lat, lng };
}

interface TileLayer {
  /**切片图层瓦片服务地址 */
  _url: string;

  /**切片图层配置项 */
  options: any;
}

/**
 * 获取智图底图瓦片服务地址
 * @param param 底图关键字
 * @returns 切片图层
 */
function getGeoqTileLayer(param?: string): TileLayer {
  let tileLayer: TileLayer;
  switch (param) {
    case "purplishBlue":
      tileLayer = L.tileLayer(
        "https://map.geoq.cn/ArcGIS/rest/services/ChinaOnlineStreetPurplishBlue/MapServer/tile/{z}/{y}/{x}"
      );
      break;
    case "community":
      tileLayer = L.tileLayer(
        "https://map.geoq.cn/ArcGIS/rest/services/ChinaOnlineCommunity/MapServer/tile/{z}/{y}/{x}"
      );
      break;
    case "warm":
      tileLayer = L.tileLayer(
        "https://map.geoq.cn/ArcGIS/rest/services/ChinaOnlineStreetWarm/MapServer/tile/{z}/{y}/{x}"
      );
      break;
    default:
      tileLayer = L.tileLayer(
        "https://map.geoq.cn/ArcGIS/rest/services/ChinaOnlineStreetGray/MapServer/tile/{z}/{y}/{x}"
      );
      break;
  }
  return tileLayer;
}

/**
 * 获取百度地图底图瓦片服务地址, 详情查看/public/js/tileLayer.baidu.js
 * @param param 底图关键字
 * @returns 切片图层
 */
function getBaiduTileLayer(param?: string): TileLayer {
  const tileLayer: TileLayer = L.tileLayer.baidu({ layer: param });
  return tileLayer;
}

export interface FactoryOption {
  /**是否不挂载鼠标移动经纬度显示 */
  isMousePosition?: boolean;

  /**是否支持双击鼠标放大 */
  isDoubleClickZoom?: boolean;

  /**使用指定的地图底图 */
  tileLayer?: string;

  /**地图中心定位 */
  center?: [number, number];

  /**地图初始化放大大小 */
  zoom?: number;

  /**是否全屏控件 */
  isShowFullScreen?: boolean;
}

/**
 * 智图地图创建工厂（火星坐标系）
 * @param el 供地图创建的dom元素
 * @param tileLayer 供地图创建的瓦片切片图层
 * @param opt 地图创建配置项
 * @returns 地图实例
 */
export const mapFactoryByGeoq = (el: any, opt?: FactoryOption): any => {
  let mapTileLayer: any = {};
  if (opt?.tileLayer) {
    mapTileLayer = getGeoqTileLayer(opt?.tileLayer);
  } else {
    mapTileLayer = getGeoqTileLayer();
  }

  if (mapTileLayer._url) {
    mapTileLayer = L.tileLayer.fallback(
      mapTileLayer._url,
      mapTileLayer.options
    );
  }

  const map: any = L.map(el, {
    center: mapConfig.center,
    // crs: CRS_4490,
    zoom: opt?.zoom || 10,
    minZoom: 5,
    maxZoom: 16,
    zoomControl: false,
    attributionControl: false,
    doubleClickZoom: opt?.isDoubleClickZoom,
    layers: [mapTileLayer]
  });

  if (opt?.isMousePosition) {
    addMousePositionByMap(map);
  }
  return map;
};

/**
 * 百度地图创建工厂
 * @param el 供地图创建的dom元素
 * @param tileLayer 供地图创建的瓦片切片图层
 * @param opt 地图创建配置项
 * @returns 地图实例
 */
export const mapFactoryByBaidu = (el: any, opt?: FactoryOption): any => {
  let mapTileLayer: any = {};
  if (opt?.tileLayer) {
    mapTileLayer = getBaiduTileLayer(opt?.tileLayer);
  } else {
    mapTileLayer = getBaiduTileLayer();
  }

  if (mapTileLayer._url) {
    mapTileLayer = L.tileLayer.fallback(
      mapTileLayer._url,
      mapTileLayer.options
    );
  }

  const mapOptions: any = {
    center: opt?.center || mapConfig.center,
    crs: L.CRS.Baidu,
    tms: true,
    zoom: opt?.zoom || mapConfig.zoom,
    minZoom: 5,
    maxZoom: 20,
    zoomControl: false,
    attributionControl: false,
    doubleClickZoom: opt?.isDoubleClickZoom,
    layers: [mapTileLayer]
  };

  if (opt?.isShowFullScreen) {
    mapOptions.fullscreenControl = true;
    mapOptions.fullscreenControlOptions = {
      position: "bottomleft"
    };
  }

  const map: any = L.map(el, mapOptions);

  if (opt?.isMousePosition) {
    addMousePositionByMap(map);
  }

  return map;
};

/**
 * 创建高德地图瓦片层
 * @param type 地图类型: vector(矢量), satellite(卫星), terrain(地形)
 */
export function createGaodeTileLayer(
  type: "vector" | "satellite" | "terrain" = "vector"
): L.TileLayer {
  // 高德专业版URL格式
  // `https://webst0{s}.is.autonavi.com/appmaptile?key=${import.meta.env.VITE_AMAP_KEY}&style=8&x={x}&y={y}&z={z}`
  const urls = {
    vector:
      "https://webrd0{s}.is.autonavi.com/appmaptile?lang=zh_cn&size=1&scale=1&style=8&x={x}&y={y}&z={z}",
    satellite:
      "https://webst0{s}.is.autonavi.com/appmaptile?style=6&x={x}&y={y}&z={z}",
    terrain:
      "https://webst0{s}.is.autonavi.com/appmaptile?style=7&x={x}&y={y}&z={z}"
  };

  return L.tileLayer(urls[type], {
    subdomains: ["1", "2", "3", "4"],
    attribution: "© 高德地图",
    maxZoom: 18
  });
}
/**
 * 在地铁上展示鼠标点位经纬度信息
 * @param map 地图实例
 */
export function addMousePositionByMap(map: any) {
  const position = "bottomright";
  L.control
    .mousePosition({
      position,
      lngFirst: true,
      separator: " / ",
      lngFormatter(val: number) {
        return "经度:" + val.toFixed(6);
      },
      latFormatter(val: number) {
        return "纬度:" + val.toFixed(6);
      }
    })
    .addTo(map);
}

/**
 * 在地图实例上创建行政区域图层
 * @param map 地图实例
 * @param data 行政区域数据
 * @param style 自定义样式配置
 */
export function addAdministrativeAivision(map: any, data: any, style?: any) {
  const layer = L.geoJSON(data, {
    style: function (feature: any) {
      return {
        color: "#ffffff",
        fillOpacity: 0,
        weight: 1,
        ...style
      };
    }
  })
    .bindPopup(function (layer: any) {
      return layer.feature.properties.name;
    })
    .addTo(map);
  return layer;
}

/**
 * 在地图实例上绘制折线叠加层
 * @param map 地图实例
 * @param data 折线叠加层数据
 */
export function addPolyline(map: any, data: any) {
  const polyline = L.polyline(data, { color: "red" }).addTo(map);
  return polyline;
}

/**热力图数据列表 */
interface HeatmapData {
  /**维度 */
  lat: string | number;
  /**经度 */
  lng: string | number;
  /**值 */
  value: number;
}
// 使用组合式处理
const createIsolatedData = (source: any[]) => {
  return source.map(item => ({
    ...item,
    coordinates: [...item.coordinates], // 克隆数组
    metadata: { ...item.metadata } // 克隆嵌套对象
  }));
};
/**
 * 在地图实例上创建热力图图层
 * 更多详情：https://www.patrick-wied.at/static/heatmapjs/
 * @param map 地图实例
 * @returns 热力图图层实例
 */
export function createHeatmapLayer(map: any, data: HeatmapData[]) {
  // 确保地图实例存在
  if (!map) {
    console.error("地图实例未初始化");
    return null;
  }
  const config = {
    // 仅当scaleRadius为真（或预期为小半径）时，半径才应小
    // 如果scaleRadius为false，则为像素中使用的恒定半径
    //如果设置为false，热图将使用全局最大值进行着色
    //如果激活：使用当前地图边界内的数据最大值
    //（UseLocalExtreme始终会出现一个红色斑点，表示为true）
    // 添加Canvas优化参数
    canvasSetup: (canvas: HTMLCanvasElement) => {
      const ctx = canvas.getContext("2d", { willReadFrequently: true });
      canvas.style.imageRendering = "optimizeQuality";
    },
    radius: 25,
    maxOpacity: 0.8,
    minOpacity: 0.3, // 添加最小透明度
    blur: 0.9, // 添加模糊效果
    scaleRadius: false, // 关闭半径自动缩放 // 根据地图缩放缩放半径
    latField: "lat",
    lngField: "lng",
    valueField: "value",
    useLocalExtrema: false, // 禁用局部极值
    // 强制数据副本模式
    dataAsCopy: true,
    // 禁用直接像素操作
    directPixelAccess: false,
    // 颜色渐变，从0.4到0.6为蓝色，0.6到0.7为绿色，0.7到1.0为红色
    gradient: {
      0.4: "blue",
      0.6: "lime",
      0.7: "yellow",
      1.0: "red"
    }
  };
  const heatmapLayer = new HeatmapOverlay(config);

  // 设置数据并添加到地图
  if (heatmapLayer) {
    // 添加异步数据加载检查
    map.whenReady(() => {
      const safeData = cloneDeep(data);
      // const safeData = structuredClone(data).map(item => ({
      //   // ... existing code ...
      // }));
      // 新增防御代码
      if (typeof HeatmapOverlay?.prototype._colorize === "function") {
        const originalColorize = HeatmapOverlay.prototype._colorize;
        HeatmapOverlay.prototype._colorize = function (imageData) {
          if (Object.isFrozen(imageData.data)) {
            imageData = new ImageData(
              new Uint8ClampedArray(imageData.data),
              imageData.width,
              imageData.height
            );
          }
          return originalColorize.call(this, imageData);
        };
      }
      heatmapLayer.setData({
        // 添加极值计算
        min: Math.min(...safeData.map(d => d.value)),
        max: Math.max(...safeData.map(d => d.value)),
        data: safeData
      });
      heatmapLayer.addTo(map);
    });
  } else {
    console.error("heatmapLayer数据有误！");
  }
  return heatmapLayer;
}

/**
 * 在地图实例上创建画布层
 * @param map 地图实例
 * @param draw 渲染函数
 * @returns 画布实例
 */
export function createMapCanvas(map: any, draw?: Function) {
  const canvasLayer = L.canvasLayer({ pane: "overlayPane" });
  if (draw) {
    canvasLayer.delegate({ onDrawLayer: draw });
  }
  canvasLayer.addTo(map);
  return canvasLayer._canvas;
}

interface MarkerClusterOption {
  /**标记点点击事件监听 */
  onClick?: Function;
}

/**
 * 在地图实例上创建集合图
 * @param map 地图实例
 * @param opt 地图创建配置项
 * @returns 地图实例
 */
export function cerateMarkerCluster(map: any, opt?: MarkerClusterOption) {
  const markercluster = L.markerClusterGroup({
    disableClusteringAtZoom: 18
  });
  if (opt) {
    if (opt.onClick) {
      markercluster.on("click", opt.onClick);
    }
  }
  map.addLayer(markercluster);
  return markercluster;
}

/**
 * 智图地图创建围栏
 * @param map 地图实例
 * @param data 围栏经纬度集合
 * @param setGroupPolygon 绘制多边形（围栏区域）的图层组
 */
export const createFence = (
  map: any,
  data: any,
  setGroupPolygon?: Function
): any => {
  if (data && data.length > 0) {
    const _points: any = [];
    // 遍历多维数组的经纬度
    for (let i = 0; i < data.length; i++) {
      const { lat, lon } = data[i];
      const bdLatLng = gcjTobd(lat, lon);
      if (i === 0) {
        map.panTo([bdLatLng.lat, bdLatLng.lng]); //将地图平移到给定的中心
      }
      _points.push([bdLatLng.lat, bdLatLng.lng]);
    }
    //绘制多边形（围栏区域）
    const polygon = L.polygon(_points, { color: "#147617" });
    //多边形（围栏区域）添加到图层组中，并在地图上绘制图层组
    if (setGroupPolygon) {
      setGroupPolygon((_groupPolygon: any) => {
        polygon.addTo(_groupPolygon);
        _groupPolygon.addTo(map);
        return _groupPolygon;
      });
    }
  }
};

/**
 * 智图地图编辑围栏上所有节点的标记
 * @param map 地图实例
 * @param data 围栏经纬度集合
 * @param setGroupMarker 绘制标记图层组
 */
export const editorFenceMarker = (
  map: any,
  data: any,
  groupMarker?: any,
  setGroupMarker?: Function
): any => {
  if (data && data.length > 0) {
    // 遍历多维数组的经纬度
    for (let i = 0; i < data.length; i++) {
      const { lat, lon } = data[i];
      const bdLatLng = gcjTobd(lat, lon);
      //添加标记
      L.marker([bdLatLng.lat, bdLatLng.lng], {
        draggable: true,
        icon: fenceIcon
      }).addTo(groupMarker);
    }
  }
  //标记添加到图层组中，并在地图上绘制图层组
  if (setGroupMarker) {
    setGroupMarker((_groupMarker: any) => {
      _groupMarker.addTo(map);
      return _groupMarker;
    });
  }
};

/**
 * 智图地图编辑围栏上,所有节点的折线叠加层
 * @param map 地图实例
 * @param data 围栏经纬度集合
 * @param groupPolyline 折线图层组
 * @param setGroupPolyline 设置折线图层组
 */
export const editorFencePolyline = (
  map: any,
  data: any,
  groupPolyline: any,
  setGroupPolyline?: Function
): any => {
  if (data && data.length > 0) {
    const latlngs: any = [];
    // 遍历多维数组的经纬度
    for (let i = 0; i < data.length; i++) {
      const { lat, lon } = data[i];
      const bdLatLng = gcjTobd(lat, lon);
      latlngs.push([bdLatLng.lat, bdLatLng.lng]);
    }
    //绘制折线
    L.polyline(latlngs, { color: "#147617" }).addTo(groupPolyline);
  }
  //折线添加到图层组中，并在地图上绘制图层组
  if (setGroupPolyline) {
    setGroupPolyline((_groupPolyliner: any) => {
      _groupPolyliner.addTo(map);
      return _groupPolyliner;
    });
  }
};

/**
 * 智图地图点击地图添加标记点
 * @param map 地图实例
 * @param groupPolyline 折线图层组
 * @param groupMarker 标记点图层组
 * @param setGroupPolyline 设置折线图层组
 * @param setGroupMarker 设置标记点图层组
 */
export const clickMap = (
  map: any,
  groupPolyline: any,
  groupMarker: any,
  setGroupPolyline?: Function,
  setGroupMarker?: Function
): any => {
  let oldLatLng: any = [];
  map.off("click");
  map.on("click", function (e: any) {
    if (setGroupMarker) {
      setGroupMarker((_groupMarker: any) => {
        //添加标记
        L.marker([e.latlng.lat, e.latlng.lng], {
          draggable: true,
          icon: fenceIcon
        }).addTo(_groupMarker);
        const polylines = groupPolyline.getLayers();
        if (polylines.length) {
          // 折线组中删除所有图层。
          groupPolyline.clearLayers();
          // 遍历折线组数，过滤掉删除的标记点，重新绘制所有的折线
          for (let i = 0; i < polylines.length; i++) {
            const item = polylines[i]._latlngs;
            item.push([e.latlng.lat, e.latlng.lng]);
            //绘制折线
            L.polyline(item, { color: "#147617" }).addTo(groupPolyline);
          }
        } else {
          //绘制折线
          L.polyline([[e.latlng.lat, e.latlng.lng]], {
            color: "#147617"
          }).addTo(groupPolyline);
        }
        _groupMarker.eachLayer(function (layer: any) {
          // 点击标记点，提示删除此标记点
          layer.on("mousedown", function (e: any) {
            const btn = document.createElement("a");
            btn.innerHTML = "删除";
            btn.onclick = function () {
              _groupMarker.removeLayer(layer);
              if (groupPolyline) {
                // 获取折线所有图层的数组。
                const polylines = groupPolyline.getLayers();
                // 折线组中删除所有图层。
                groupPolyline.clearLayers();
                // 遍历折线组数，过滤掉删除的标记点，重新绘制所有的折线
                for (let i = 0; i < polylines.length; i++) {
                  const item = polylines[i]._latlngs;
                  const latlngs: any = [];
                  for (let j = 0; j < item.length; j++) {
                    if (item[j].lat !== e.target._latlng.lat) {
                      latlngs.push([item[j].lat, item[j].lng]);
                    }
                  }
                  //绘制折线
                  const polyline = L.polyline(latlngs, { color: "#147617" });
                  //折线添加到图层组中，并在地图上绘制图层组
                  if (setGroupPolyline) {
                    setGroupPolyline((_groupPolyliner: any) => {
                      polyline.addTo(_groupPolyliner);
                      _groupPolyliner.addTo(map);
                      return _groupPolyliner;
                    });
                  }
                }
              }
            };
            layer.bindPopup(btn);
          });
          // 开始拖动marker，记录原坐标
          layer.on("movestart", function (e: any) {
            oldLatLng = [e.target._latlng.lat, e.target._latlng.lng];
          });
          // 结束拖动marker，新坐标替换原坐标
          layer.on("moveend", function (e: any) {
            if (groupPolyline) {
              // 获取折线所有图层的数组。
              const polylines = groupPolyline.getLayers();
              // 折线组中删除所有图层。
              groupPolyline.clearLayers();
              // 遍历折线组数，过滤掉删除的标记点，重新绘制所有的折线
              for (let i = 0; i < polylines.length; i++) {
                const item = polylines[i]._latlngs;
                const latlngs: any = [];
                for (let j = 0; j < item.length; j++) {
                  const lls = [item[j].lat, item[j].lng];
                  if (JSON.stringify(oldLatLng) === JSON.stringify(lls)) {
                    latlngs[j] = [e.target._latlng.lat, e.target._latlng.lng];
                  } else {
                    latlngs.push([item[j].lat, item[j].lng]);
                  }
                }
                //绘制折线
                const polyline = L.polyline(latlngs, { color: "#147617" });
                //折线添加到图层组中，并在地图上绘制图层组
                if (setGroupPolyline) {
                  setGroupPolyline((_groupPolyliner: any) => {
                    polyline.addTo(_groupPolyliner);
                    _groupPolyliner.addTo(map);
                    return _groupPolyliner;
                  });
                }
              }
            }
          });
        });
        return _groupMarker;
      });
    }
  });
};

/**
 * 智图地图编辑围栏上标记的拖动和删除
 * @param map 地图实例
 * @param groupPolyline 折线图层组
 * @param setGroupPolyline 设置折线图层组
 * @param setGroupMarker 设置标记点图层组
 * @param groupMarker 标记点图层组
 */
export const fenceMarkerEditor = (
  map: any,
  groupPolyline: any,
  setGroupPolyline?: Function,
  setGroupMarker?: Function,
  groupMarker?: any
): any => {
  let oldLatLng: any = [];
  if (setGroupMarker) {
    setGroupMarker((_groupMarker: any) => {
      _groupMarker.eachLayer(function (layer: any) {
        // 点击标记点，提示删除此标记点
        layer.on("mousedown", function (e: any) {
          const btn = document.createElement("a");
          btn.innerHTML = "删除";
          btn.onclick = function () {
            _groupMarker.removeLayer(layer);
            if (groupPolyline) {
              // 获取折线所有图层的数组。
              const polylines = groupPolyline.getLayers();
              // 折线组中删除所有图层。
              groupPolyline.clearLayers();
              // 遍历折线组数，过滤掉删除的标记点，重新绘制所有的折线
              for (let i = 0; i < polylines.length; i++) {
                const item = polylines[i]._latlngs;
                const latlngs: any = [];
                for (let j = 0; j < item.length; j++) {
                  if (item[j].lat !== e.target._latlng.lat) {
                    latlngs.push([item[j].lat, item[j].lng]);
                  }
                }
                //绘制折线
                const polyline = L.polyline(latlngs, { color: "#147617" });
                //折线添加到图层组中，并在地图上绘制图层组
                if (setGroupPolyline) {
                  setGroupPolyline((_groupPolyliner: any) => {
                    polyline.addTo(_groupPolyliner);
                    _groupPolyliner.addTo(map);
                    return _groupPolyliner;
                  });
                }
              }
            }
          };
          layer.bindPopup(btn);
        });
        // 开始拖动marker，记录原坐标
        layer.on("movestart", function (e: any) {
          oldLatLng = [e.target._latlng.lat, e.target._latlng.lng];
        });
        // 结束拖动marker，新坐标替换原坐标
        layer.on("moveend", function (e: any) {
          if (groupPolyline) {
            // 获取折线所有图层的数组。
            const polylines = groupPolyline.getLayers();
            // 折线组中删除所有图层。
            groupPolyline.clearLayers();
            // 遍历折线组数，过滤掉删除的标记点，重新绘制所有的折线
            for (let i = 0; i < polylines.length; i++) {
              const item = polylines[i]._latlngs;
              const latlngs: any = [];
              for (let j = 0; j < item.length; j++) {
                const lls = [item[j].lat, item[j].lng];
                if (JSON.stringify(oldLatLng) === JSON.stringify(lls)) {
                  latlngs[j] = [e.target._latlng.lat, e.target._latlng.lng];
                } else {
                  latlngs.push([item[j].lat, item[j].lng]);
                }
              }
              //绘制折线
              const polyline = L.polyline(latlngs, { color: "#147617" });
              //折线添加到图层组中，并在地图上绘制图层组
              if (setGroupPolyline) {
                setGroupPolyline((_groupPolyliner: any) => {
                  polyline.addTo(_groupPolyliner);
                  _groupPolyliner.addTo(map);
                  return _groupPolyliner;
                });
              }
            }
          }
        });
      });
      return _groupMarker;
    });
  }
};

/**
 * 智图地图围栏完成编辑
 * @param map 地图实例
 * @param groupPolyline 折线图层组
 * @param setGroupPolygon 设置多边形图层组
 */
export const completeFence = (
  map: any,
  groupPolyline: any,
  groupPolygon: any,
  setGroupPolygon?: Function
): any => {
  const arr = [];
  if (groupPolyline) {
    // 获取折线所有图层的数组。
    const polylines = groupPolyline.getLayers();
    // 遍历折线组数，过滤掉删除的标记点，重新绘制所有的折线
    for (let i = 0; i < polylines.length; i++) {
      const item = polylines[i]._latlngs;
      const latlngs: any = [];
      for (let j = 0; j < item.length; j++) {
        latlngs.push([item[j].lat, item[j].lng]);
      }
      arr.push(latlngs);
      //绘制多边形（围栏区域）
      const polygon = L.polygon(arr, { color: "#147617" });
      //多边形（围栏区域）添加到图层组中，并在地图上绘制图层组
      if (setGroupPolygon) {
        setGroupPolygon((_groupPolygon: any) => {
          if (_groupPolygon) {
            _groupPolygon.clearLayers();
          }
          polygon.addTo(_groupPolygon);
          _groupPolygon.addTo(map);
          return _groupPolygon;
        });
      }
    }
  }
  const newFenceData: any = [];
  for (let a = 0; a < arr.length; a++) {
    const item = arr[a];
    for (let b = 0; b < item.length; b++) {
      const latLng = bdTogcj(item[b][0], item[b][1]);
      newFenceData.push({ lat: latLng.lat, lon: latLng.lng });
    }
  }
  return newFenceData;
};

// 新增高德地图工厂函数
export const mapFactoryByGaode = (el: string, opt?: FactoryOption): any => {
  const map = L.map(el, {
    center: opt?.center || MAP_CENTER,
    zoom: opt?.zoom || 12,
    crs: L.CRS.EPSG3857 // 高德标准坐标系
  });

  // 添加高德矢量图层
  createGaodeTileLayer(opt?.tileType || "vector").addTo(map);

  // 添加控件（比例尺、鼠标位置等）
  L.control.scale().addTo(map);
  opt?.isMousePosition && addMousePositionByMap(map);

  return map;
};
